﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using SaleManagement.Domains;
using SaleManagement.Data;
using SaleManagement.Data.Bases;

#endregion

namespace SaleManagement.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
		private static volatile Configuration _config = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <c cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("SaleManagement.Data") as NetTiersServiceSection;
				}

				#region Design-Time Support

				if ( _section == null )
				{
					// lastly, try to find the specific NetTiersServiceSection for this assembly
					foreach ( ConfigurationSection temp in Configuration.Sections )
					{
						if ( temp is NetTiersServiceSection )
						{
							_section = temp as NetTiersServiceSection;
							break;
						}
					}
				}

				#endregion Design-Time Support
				
				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#region Design-Time Support

		/// <summary>
		/// Gets a reference to the application configuration object.
		/// </summary>
		public static Configuration Configuration
		{
			get
			{
				if ( _config == null )
				{
					// load specific config file
					if ( HttpContext.Current != null )
					{
						_config = WebConfigurationManager.OpenWebConfiguration("~");
					}
					else
					{
						String configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile.Replace(".config", "").Replace(".temp", "");

						// check for design mode
						if ( configFile.ToLower().Contains("devenv.exe") )
						{
							_config = GetDesignTimeConfig();
						}
						else
						{
							_config = ConfigurationManager.OpenExeConfiguration(configFile);
						}
					}
				}

				return _config;
			}
		}

		private static Configuration GetDesignTimeConfig()
		{
			ExeConfigurationFileMap configMap = null;
			Configuration config = null;
			String path = null;

			// Get an instance of the currently running Visual Studio IDE.
			EnvDTE80.DTE2 dte = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.9.0");
			
			if ( dte != null )
			{
				dte.SuppressUI = true;

				EnvDTE.ProjectItem item = dte.Solution.FindProjectItem("web.config");
				if ( item != null )
				{
					if (!item.ContainingProject.FullName.ToLower().StartsWith("http:"))
               {
                  System.IO.FileInfo info = new System.IO.FileInfo(item.ContainingProject.FullName);
                  path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = path;
               }
               else
               {
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = item.get_FileNames(0);
               }}

				/*
				Array projects = (Array) dte2.ActiveSolutionProjects;
				EnvDTE.Project project = (EnvDTE.Project) projects.GetValue(0);
				System.IO.FileInfo info;

				foreach ( EnvDTE.ProjectItem item in project.ProjectItems )
				{
					if ( String.Compare(item.Name, "web.config", true) == 0 )
					{
						info = new System.IO.FileInfo(project.FullName);
						path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
						configMap = new ExeConfigurationFileMap();
						configMap.ExeConfigFilename = path;
						break;
					}
				}
				*/
			}

			config = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
			return config;
		}

		#endregion Design-Time Support

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
				// use default ConnectionStrings if _section has already been discovered
				if ( _config == null && _section != null )
				{
					return WebConfigurationManager.ConnectionStrings;
				}
				
				return Configuration.ConnectionStrings.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region PurchaseProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Purchase"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PurchaseProviderBase PurchaseProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PurchaseProvider;
			}
		}
		
		#endregion
		
		#region PriceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Price"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PriceProviderBase PriceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PriceProvider;
			}
		}
		
		#endregion
		
		#region PreviousPurchaseProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PreviousPurchase"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PreviousPurchaseProviderBase PreviousPurchaseProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PreviousPurchaseProvider;
			}
		}
		
		#endregion
		
		#region ImportProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Import"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ImportProviderBase ImportProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ImportProvider;
			}
		}
		
		#endregion
		
		#region AccessoryImportProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AccessoryImport"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AccessoryImportProviderBase AccessoryImportProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AccessoryImportProvider;
			}
		}
		
		#endregion
		
		#region ProductProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Product"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ProductProviderBase ProductProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ProductProvider;
			}
		}
		
		#endregion
		
		#region ProductGroupProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ProductGroup"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ProductGroupProviderBase ProductGroupProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ProductGroupProvider;
			}
		}
		
		#endregion
		
		#region RepositoryProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Repository"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static RepositoryProviderBase RepositoryProvider
		{
			get 
			{
				LoadProviders();
				return _provider.RepositoryProvider;
			}
		}
		
		#endregion
		
		#region PaymentDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PaymentDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PaymentDetailProviderBase PaymentDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PaymentDetailProvider;
			}
		}
		
		#endregion
		
		#region PurchaseDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PurchaseDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PurchaseDetailProviderBase PurchaseDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PurchaseDetailProvider;
			}
		}
		
		#endregion
		
		#region StoredProductProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="StoredProduct"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static StoredProductProviderBase StoredProductProvider
		{
			get 
			{
				LoadProviders();
				return _provider.StoredProductProvider;
			}
		}
		
		#endregion
		
		#region UserProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="User"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UserProviderBase UserProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UserProvider;
			}
		}
		
		#endregion
		
		#region PaymentProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Payment"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PaymentProviderBase PaymentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PaymentProvider;
			}
		}
		
		#endregion
		
		#region BackupPurchaseProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BackupPurchase"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BackupPurchaseProviderBase BackupPurchaseProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BackupPurchaseProvider;
			}
		}
		
		#endregion
		
		#region ImportDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ImportDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ImportDetailProviderBase ImportDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ImportDetailProvider;
			}
		}
		
		#endregion
		
		#region AccImportDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AccImportDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AccImportDetailProviderBase AccImportDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AccImportDetailProvider;
			}
		}
		
		#endregion
		
		#region BackupPurchaseDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BackupPurchaseDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BackupPurchaseDetailProviderBase BackupPurchaseDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BackupPurchaseDetailProvider;
			}
		}
		
		#endregion
		
		#region CustomerProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Customer"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CustomerProviderBase CustomerProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CustomerProvider;
			}
		}
		
		#endregion
		
		#region ExportProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Export"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ExportProviderBase ExportProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ExportProvider;
			}
		}
		
		#endregion
		
		#region GuaranteeListProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GuaranteeList"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GuaranteeListProviderBase GuaranteeListProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GuaranteeListProvider;
			}
		}
		
		#endregion
		
		#region ExportDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ExportDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ExportDetailProviderBase ExportDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ExportDetailProvider;
			}
		}
		
		#endregion
		
		#region GuaranteeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Guarantee"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GuaranteeProviderBase GuaranteeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GuaranteeProvider;
			}
		}
		
		#endregion
		
		#region FunctionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Function"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static FunctionProviderBase FunctionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.FunctionProvider;
			}
		}
		
		#endregion
		
		#region UserFunctionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UserFunction"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UserFunctionProviderBase UserFunctionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UserFunctionProvider;
			}
		}
		
		#endregion
		
		
		#endregion
	}
	
	#region Query/Filters
		
	#region PurchaseFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Purchase"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PurchaseFilters : PurchaseFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PurchaseFilters class.
		/// </summary>
		public PurchaseFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PurchaseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PurchaseFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PurchaseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PurchaseFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PurchaseFilters
	
	#region PurchaseQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PurchaseParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Purchase"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PurchaseQuery : PurchaseParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PurchaseQuery class.
		/// </summary>
		public PurchaseQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PurchaseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PurchaseQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PurchaseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PurchaseQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PurchaseQuery
		
	#region PriceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Price"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PriceFilters : PriceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PriceFilters class.
		/// </summary>
		public PriceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PriceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PriceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PriceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PriceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PriceFilters
	
	#region PriceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PriceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Price"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PriceQuery : PriceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PriceQuery class.
		/// </summary>
		public PriceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PriceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PriceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PriceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PriceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PriceQuery
		
	#region PreviousPurchaseFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PreviousPurchase"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PreviousPurchaseFilters : PreviousPurchaseFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PreviousPurchaseFilters class.
		/// </summary>
		public PreviousPurchaseFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PreviousPurchaseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PreviousPurchaseFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PreviousPurchaseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PreviousPurchaseFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PreviousPurchaseFilters
	
	#region PreviousPurchaseQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PreviousPurchaseParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PreviousPurchase"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PreviousPurchaseQuery : PreviousPurchaseParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PreviousPurchaseQuery class.
		/// </summary>
		public PreviousPurchaseQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PreviousPurchaseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PreviousPurchaseQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PreviousPurchaseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PreviousPurchaseQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PreviousPurchaseQuery
		
	#region ImportFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Import"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImportFilters : ImportFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImportFilters class.
		/// </summary>
		public ImportFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImportFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImportFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImportFilters
	
	#region ImportQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ImportParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Import"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImportQuery : ImportParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImportQuery class.
		/// </summary>
		public ImportQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImportQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImportQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImportQuery
		
	#region AccessoryImportFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AccessoryImport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AccessoryImportFilters : AccessoryImportFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AccessoryImportFilters class.
		/// </summary>
		public AccessoryImportFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AccessoryImportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AccessoryImportFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AccessoryImportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AccessoryImportFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AccessoryImportFilters
	
	#region AccessoryImportQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AccessoryImportParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AccessoryImport"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AccessoryImportQuery : AccessoryImportParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AccessoryImportQuery class.
		/// </summary>
		public AccessoryImportQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AccessoryImportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AccessoryImportQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AccessoryImportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AccessoryImportQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AccessoryImportQuery
		
	#region ProductFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Product"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductFilters : ProductFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductFilters class.
		/// </summary>
		public ProductFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductFilters
	
	#region ProductQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ProductParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Product"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductQuery : ProductParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductQuery class.
		/// </summary>
		public ProductQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductQuery
		
	#region ProductGroupFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ProductGroup"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductGroupFilters : ProductGroupFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductGroupFilters class.
		/// </summary>
		public ProductGroupFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductGroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductGroupFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductGroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductGroupFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductGroupFilters
	
	#region ProductGroupQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ProductGroupParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ProductGroup"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductGroupQuery : ProductGroupParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductGroupQuery class.
		/// </summary>
		public ProductGroupQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductGroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductGroupQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductGroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductGroupQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductGroupQuery
		
	#region RepositoryFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Repository"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RepositoryFilters : RepositoryFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RepositoryFilters class.
		/// </summary>
		public RepositoryFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the RepositoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RepositoryFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RepositoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RepositoryFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RepositoryFilters
	
	#region RepositoryQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="RepositoryParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Repository"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class RepositoryQuery : RepositoryParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the RepositoryQuery class.
		/// </summary>
		public RepositoryQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the RepositoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public RepositoryQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the RepositoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public RepositoryQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion RepositoryQuery
		
	#region PaymentDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PaymentDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentDetailFilters : PaymentDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentDetailFilters class.
		/// </summary>
		public PaymentDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentDetailFilters
	
	#region PaymentDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PaymentDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PaymentDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentDetailQuery : PaymentDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentDetailQuery class.
		/// </summary>
		public PaymentDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentDetailQuery
		
	#region PurchaseDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PurchaseDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PurchaseDetailFilters : PurchaseDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PurchaseDetailFilters class.
		/// </summary>
		public PurchaseDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PurchaseDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PurchaseDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PurchaseDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PurchaseDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PurchaseDetailFilters
	
	#region PurchaseDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PurchaseDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PurchaseDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PurchaseDetailQuery : PurchaseDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PurchaseDetailQuery class.
		/// </summary>
		public PurchaseDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PurchaseDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PurchaseDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PurchaseDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PurchaseDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PurchaseDetailQuery
		
	#region StoredProductFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="StoredProduct"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StoredProductFilters : StoredProductFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StoredProductFilters class.
		/// </summary>
		public StoredProductFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the StoredProductFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StoredProductFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StoredProductFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StoredProductFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StoredProductFilters
	
	#region StoredProductQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="StoredProductParameterBuilder"/> class
	/// that is used exclusively with a <see cref="StoredProduct"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class StoredProductQuery : StoredProductParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the StoredProductQuery class.
		/// </summary>
		public StoredProductQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the StoredProductQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public StoredProductQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the StoredProductQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public StoredProductQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion StoredProductQuery
		
	#region UserFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="User"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserFilters : UserFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserFilters class.
		/// </summary>
		public UserFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserFilters
	
	#region UserQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UserParameterBuilder"/> class
	/// that is used exclusively with a <see cref="User"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserQuery : UserParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserQuery class.
		/// </summary>
		public UserQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserQuery
		
	#region PaymentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Payment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentFilters : PaymentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentFilters class.
		/// </summary>
		public PaymentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentFilters
	
	#region PaymentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PaymentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Payment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentQuery : PaymentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentQuery class.
		/// </summary>
		public PaymentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentQuery
		
	#region BackupPurchaseFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BackupPurchase"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BackupPurchaseFilters : BackupPurchaseFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseFilters class.
		/// </summary>
		public BackupPurchaseFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BackupPurchaseFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BackupPurchaseFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BackupPurchaseFilters
	
	#region BackupPurchaseQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BackupPurchaseParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BackupPurchase"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BackupPurchaseQuery : BackupPurchaseParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseQuery class.
		/// </summary>
		public BackupPurchaseQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BackupPurchaseQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BackupPurchaseQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BackupPurchaseQuery
		
	#region ImportDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ImportDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImportDetailFilters : ImportDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImportDetailFilters class.
		/// </summary>
		public ImportDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImportDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImportDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImportDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImportDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImportDetailFilters
	
	#region ImportDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ImportDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ImportDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ImportDetailQuery : ImportDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ImportDetailQuery class.
		/// </summary>
		public ImportDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ImportDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ImportDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ImportDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ImportDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ImportDetailQuery
		
	#region AccImportDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AccImportDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AccImportDetailFilters : AccImportDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AccImportDetailFilters class.
		/// </summary>
		public AccImportDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AccImportDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AccImportDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AccImportDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AccImportDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AccImportDetailFilters
	
	#region AccImportDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AccImportDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AccImportDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AccImportDetailQuery : AccImportDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AccImportDetailQuery class.
		/// </summary>
		public AccImportDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AccImportDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AccImportDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AccImportDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AccImportDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AccImportDetailQuery
		
	#region BackupPurchaseDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BackupPurchaseDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BackupPurchaseDetailFilters : BackupPurchaseDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseDetailFilters class.
		/// </summary>
		public BackupPurchaseDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BackupPurchaseDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BackupPurchaseDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BackupPurchaseDetailFilters
	
	#region BackupPurchaseDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BackupPurchaseDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BackupPurchaseDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BackupPurchaseDetailQuery : BackupPurchaseDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseDetailQuery class.
		/// </summary>
		public BackupPurchaseDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BackupPurchaseDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BackupPurchaseDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BackupPurchaseDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BackupPurchaseDetailQuery
		
	#region CustomerFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Customer"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CustomerFilters : CustomerFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CustomerFilters class.
		/// </summary>
		public CustomerFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CustomerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CustomerFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CustomerFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CustomerFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CustomerFilters
	
	#region CustomerQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CustomerParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Customer"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CustomerQuery : CustomerParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CustomerQuery class.
		/// </summary>
		public CustomerQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CustomerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CustomerQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CustomerQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CustomerQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CustomerQuery
		
	#region ExportFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Export"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ExportFilters : ExportFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ExportFilters class.
		/// </summary>
		public ExportFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ExportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ExportFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ExportFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ExportFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ExportFilters
	
	#region ExportQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ExportParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Export"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ExportQuery : ExportParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ExportQuery class.
		/// </summary>
		public ExportQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ExportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ExportQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ExportQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ExportQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ExportQuery
		
	#region GuaranteeListFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GuaranteeList"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GuaranteeListFilters : GuaranteeListFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GuaranteeListFilters class.
		/// </summary>
		public GuaranteeListFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeListFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GuaranteeListFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeListFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GuaranteeListFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GuaranteeListFilters
	
	#region GuaranteeListQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GuaranteeListParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GuaranteeList"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GuaranteeListQuery : GuaranteeListParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GuaranteeListQuery class.
		/// </summary>
		public GuaranteeListQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeListQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GuaranteeListQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeListQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GuaranteeListQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GuaranteeListQuery
		
	#region ExportDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ExportDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ExportDetailFilters : ExportDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ExportDetailFilters class.
		/// </summary>
		public ExportDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ExportDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ExportDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ExportDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ExportDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ExportDetailFilters
	
	#region ExportDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ExportDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ExportDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ExportDetailQuery : ExportDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ExportDetailQuery class.
		/// </summary>
		public ExportDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ExportDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ExportDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ExportDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ExportDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ExportDetailQuery
		
	#region GuaranteeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Guarantee"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GuaranteeFilters : GuaranteeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GuaranteeFilters class.
		/// </summary>
		public GuaranteeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GuaranteeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GuaranteeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GuaranteeFilters
	
	#region GuaranteeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GuaranteeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Guarantee"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GuaranteeQuery : GuaranteeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GuaranteeQuery class.
		/// </summary>
		public GuaranteeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GuaranteeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GuaranteeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GuaranteeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GuaranteeQuery
		
	#region FunctionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Function"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FunctionFilters : FunctionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FunctionFilters class.
		/// </summary>
		public FunctionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the FunctionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FunctionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FunctionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FunctionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FunctionFilters
	
	#region FunctionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="FunctionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Function"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FunctionQuery : FunctionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FunctionQuery class.
		/// </summary>
		public FunctionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the FunctionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FunctionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FunctionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FunctionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FunctionQuery
		
	#region UserFunctionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UserFunction"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserFunctionFilters : UserFunctionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserFunctionFilters class.
		/// </summary>
		public UserFunctionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserFunctionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserFunctionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserFunctionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserFunctionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserFunctionFilters
	
	#region UserFunctionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UserFunctionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UserFunction"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserFunctionQuery : UserFunctionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserFunctionQuery class.
		/// </summary>
		public UserFunctionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserFunctionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserFunctionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserFunctionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserFunctionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserFunctionQuery
	#endregion

	
}
